{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "首先说明一下Actor-critic是一系列算法，或者说Actor-critic是一种思想。演员评论家的思想，通过评论家来指导演员的行为,使学习更加有效率.\n",
    "\n",
    "所以会有一系列的变种，Advantage Actor-critic(A2C),Asynchronous Actor-Critic Agents(A3C)\n",
    "\n",
    "最开始的AC我并没有找到论文,只找到了[这本书](https://papers.nips.cc/paper/1786-actor-critic-algorithms.pdf),所以我这次就实现A2C了.\n",
    "\n",
    "最开始的Actor-critic使用的Actor网络是REINFORCE,之后再转换到Policy Gradient，再到$\\delta_v$,三者最主要的区别为\n",
    "\n",
    "REINFORCE使用$V$,Policy Gradient使用$\\hat{A}(s,a)=Q(s,a)-V(s)$,而$\\delta_v=r+\\gamma V_v(s')-V_v(s)$来替换如下的$\\square$处:\n",
    "\n",
    "$$\\theta_{t+1} = \\theta_t +\\alpha\\square\\nabla_\\theta \\log\\pi_\\theta(s|a)$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在理解$\\hat{A}(s,a)=Q(s,a)-V(s)$的过程中，产生了一些疑惑。因为实际 $V$ 值是通过神经网络返回单值获取的，代表当前状态的价值。而目标 $V$ 值\n",
    "\n",
    "的计算是reward序列的加权累加所得的。所以TD error就这么产生了\n",
    "\n",
    "联系到 DuelingDQN，$Q(s,a)=A(s,a)-V(s)$，其V值使用的是实际的V值，因为Q-learning系列算法使用的都是TD(1)的更新方式，不存在目标 $V$ 值的出现\n",
    "\n",
    "贴上V和Q的计算公式吧，以免日后忘记([参考于此](https://datascience.stackexchange.com/questions/9832/what-is-the-q-function-and-what-is-the-v-function-in-reinforcement-learning))\n",
    "$$V^\\pi(s)=\\mathbb{E}_\\pi[G_t|s_t=s]$$\n",
    "$$Q^\\pi(s,a)=\\mathbb{E}_\\pi[G_t|s_t=s,a_t=a]$$\n",
    "V和Q的关系($\\pi$为概率):\n",
    "$$V^\\pi(s)=\\sum_{a \\in A}\\pi(a|s) * Q^\\pi(a,s)$$\n",
    "V为所以Q采取状态的加权总和，通过上面的公式很难知道两者的区别，顶多就是一个和action有关，一个和action无关所以我们将Q定义的更加具体:\n",
    "$$Q(s,a)=r(s,a)+\\gamma V^∗(\\delta(s,a))$$\n",
    "其中 $V^*$ 为在某个状态所采取的最佳action\n",
    "$$V^*(s) = {\\max_{a'}}Q(s,a')$$\n",
    "于是可以将$Q(s,a)$表示为:\n",
    "$$Q(s,a)=r(s,a)+\\gamma {\\max_{a′}}Q(\\delta(s,a),a′)$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "算法伪代码:<br>\n",
    "Input a differentiable policy parameterization $\\pi(a|s,\\theta_\\pi)$<br>\n",
    "Input a differentiable state-value parameterization $\\hat{v}(s, \\theta_{\\hat{v}})$<br>\n",
    "Select step-size parameters $0<\\alpha_\\pi,\\alpha_{\\hat{v}}\\leq 1$<br>\n",
    "Initialize the parameters $\\theta_{pi}, \\theta_{\\hat{v}}$<br>\n",
    "Loop through $n$ episodes (or forever):<br>\n",
    "&nbsp;&nbsp;&nbsp; Begin the episode $s_0$<br>\n",
    "&nbsp;&nbsp;&nbsp; Continue to loop until the episode ends:<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Get action $A_t$ from $\\pi$:$\\pi(S_t,\\theta_\\pi) \\to A_t$<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Take action $A_t$ and observe reward ($R_t$) and the new state($S_{t+1}$)<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Calculate the TD target:$G_t \\leftarrow R_t + \\gamma \\hat{v}(S_{t+1},\\theta_{\\hat{v}})$<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Calculate the TD error:$\\delta_t\\leftarrow R_t +\\gamma\\hat{v}(S_{t+1},\\theta_{\\hat{v}})-\\hat{v}(S_t,\\theta_{\\hat{v}})$<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Calculate the critic loss $L(\\theta_{\\hat{v}})=\\frac{1}{T}\\sum^T_{t=1}(\\hat{v}(S_t,\\theta_\\hat{v})-G_t)^2$<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Calculate the actor loss $L(\\theta\\pi)=-\\sum^T_{t=1}ln(\\pi(A_t|S_t,\\theta_\\pi))\\delta_t$<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Update actor parameters through backpropagation:$\\theta_\\pi:=\\theta_\\pi+\\alpha_\\pi\\nabla_\\pi L(\\theta_\\pi)$<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Update critic parameters through backpropagation:$\\theta_{\\hat{v}}:=\\theta_{\\hat{v}}+\\alpha_{\\hat{v}}\\nabla_{\\hat{v}}L(\\theta_{\\hat{v}})$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![actor_critic_image](../assets/actor_critic_image.png)<br>\n",
    "在真正实现的时候，TD target使用的是每次奖励乘上折扣值的和也就是$G_t$\n",
    "\n",
    "而TD error中的 $\\hat{v}(S_t,\\theta_{\\hat{v}})$指的是当前状态的V值\n",
    "\n",
    "在计算Loss的时候我们会将$L(\\theta\\pi)$,$L(\\theta_{\\hat{v}})$相加并再加上一个熵(entropy)函数$H(\\pi)=\\mathbb{E}_{i\\sim 0,1,\\dots ,n}(-\\log y_i)=-\\sum^n_{i=1} P(x_i)log_b(P(x_i)))$<br>\n",
    "公式中$P(x_i)$为动作i的概率，$log_b$中的b为动作的状态空间，也可直接为自然对数\n",
    "\n",
    "所以总的Loss funciton为:\n",
    "$$L = 0.5 * \\frac{1}{T}\\sum^T_{t=1}(\\hat{v}(S_t,\\theta_\\hat{v})-G_t)^2  -\\sum^T_{t=1}ln(\\pi(A_t|S_t,\\theta_\\pi))\\delta_t - \\beta * H(\\pi)$$\n",
    "\n",
    "在动作sample的时候使用的虽然是actor，但计算Loss的时候加上了critic loss, critic loss 乘上了0.5是为了使求导之后和policy loss保持同一个级数(为什么要保持同一个级数???,机器学习是为了计算方便)。这样一来，就可以理解critic为什么对actor有指导作用了。actor sample了不好的action,会造成较高的critic loss,由此对actor进行惩罚。反之，critic loss较低，对actor进行奖励(此处的奖励和惩罚是相对的)。\n",
    "但是，critic不一定就是正确的。在critic成熟之前，必须要做出更多的探索，不然会容易会陷入局部。由此有了熵函数的出现。\n",
    "\n",
    "由熵函数定义和下图可知: 以二元分布为例，当两者被sample的概率相等时(熵函数的目标是达到这种状态)，熵函数是最大的。当两者被sample的概率一个为0一个为1时熵函数是最小的。加到损失函数中时会乘上-1，则相反。由此，当分布过于极端(一个为0，一个为1)时会得到较高的loss，将参数重重地更新一次。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A2C的四种实现方式 :其主要区别在于TD_error中TD_target的实现方式和所使用的数据来源<br>\n",
    "1. One-step Actor-Critic:<br>\n",
    "    TD_target = $R+\\gamma\\hat{v}(S',w)$,其中 $\\hat{v}$ 使用的为下个state的value值\n",
    "    * 使用环境的单次更新来实现(不实用)\n",
    "    * 使用和环境的一次完整的互动(开始训练直到done)。将其转化为多维数组，作为一个batch进行更新,[链接](https://github.com/seungeunrho/minimalRL/blob/master/actor_critic.py)\n",
    "2. 路径更新\n",
    "    TD_target = $R+\\gamma\\hat{v}(S',w)$,其中 $\\hat{v}$ 使用的为整条路径的$V(t)$，也就是说使用reward来进行无偏估计\n",
    "    * 使用单个环境，使用一次完整的互动(开始训练直到done)。[链接](https://github.com/pytorch/examples/blob/master/reinforcement_learning/actor_critic.py)\n",
    "    * 使用多个环境，但每个环境是同步的，环境们互动几次后再更新。[链接](https://github.com/higgsfield/RL-Adventure-2/blob/master/1.actor-critic.ipynb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "x = np.arange(0.01,1,0.01)\n",
    "y = lambda x :-(x * np.log2(x)+(1-x)*np.log2(1-x))\n",
    "plt.xlabel('$P(x=0)=α$')\n",
    "plt.ylabel('H(Π)')\n",
    "plt.title('The distribution of H(Π) (When the probability of X=0 equal α,and the X=1 equal 1-α)')\n",
    "plt.plot(x, y(x))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import gym\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "import torch.nn.functional as F\n",
    "from torch.distributions import Categorical\n",
    "import torch.multiprocessing as mp\n",
    "import time\n",
    "import numpy as np\n",
    "from IPython.display import clear_output\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import random\n",
    "from statistics import mean\n",
    "device = torch.device('cuda:1' if torch.cuda.is_available() else 'cpu')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "实现多个环境同步，共同更新actor-critic网络<br>\n",
    "可以理解为每个master_end对应一个worker_end。worker_end是client,master_end是server"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "code_folding": [
     0
    ]
   },
   "outputs": [],
   "source": [
    "def worker(worker_id, master_end, worker_end, env_name):\n",
    "    master_end.close() # 禁止 worker 使用主终端发送信息\n",
    "    env = gym.make(env_name)\n",
    "    env.seed(worker_id) # 让每个env初始参数都不同，如果相同，就成一个env了\n",
    "    \n",
    "    while True:\n",
    "        cmd, data = worker_end.recv() # 从 master_end 端接收信息\n",
    "        if cmd == 'step':\n",
    "            ob, reward, done, info = env.step(data)\n",
    "            if done:\n",
    "                ob = env.reset()\n",
    "            worker_end.send((ob, reward, done, info)) # 发送返回给 master_end 端\n",
    "        elif cmd == 'reset':\n",
    "            ob = env.reset()\n",
    "            worker_end.send(ob)\n",
    "        elif cmd == 'reset_task':\n",
    "            ob = env.reset_task()\n",
    "            worker_end.send(ob)\n",
    "        elif cmd == 'close':\n",
    "            worker_end.close()\n",
    "            break\n",
    "        elif cmd == 'get_spaces':\n",
    "            worker_end.send((env.observation_space.shape[0], env.action_space.n))\n",
    "        else:\n",
    "            raise NotImplementedError"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "code_folding": [
     0
    ]
   },
   "outputs": [],
   "source": [
    "class ParallelEnv:\n",
    "    def __init__(self, n_train_processes, env_name):\n",
    "        self.nenvs = n_train_processes\n",
    "        self.waiting = False\n",
    "        self.closed = False\n",
    "        self.workers = []\n",
    "        self.env_name = env_name\n",
    "        \n",
    "        self.master_ends, self.worker_ends = zip(*[mp.Pipe() for _ in range(self.nenvs)])\n",
    "        \n",
    "        for worker_id, (master_end, worker_end) in enumerate(zip(self.master_ends, self.worker_ends)):\n",
    "            p = mp.Process(target=worker, args=(worker_id, master_end, worker_end, self.env_name))\n",
    "            p.daemon = True\n",
    "            p.start()\n",
    "            self.workers.append(p)\n",
    "        for worker_end in self.worker_ends:\n",
    "            worker_end.close()\n",
    "        \n",
    "        self.master_ends[0].send(('get_spaces', None))\n",
    "        self.observation_space, self.action_space = self.master_ends[0].recv()\n",
    "    \n",
    "    def step_async(self, actions):\n",
    "        for master_end, action in zip(self.master_ends, actions):\n",
    "            master_end.send(('step', action))\n",
    "        self.waiting = True\n",
    "        \n",
    "    def step_wait(self):\n",
    "        results = [master_end.recv() for master_end in self.master_ends]\n",
    "        self.waiting = False\n",
    "        obs, rews, dones, infos = zip(*results)\n",
    "        return np.stack(obs), np.stack(rews), np.stack(dones), infos\n",
    "    \n",
    "    def reset(self):\n",
    "        for master_end in self.master_ends:\n",
    "            master_end.send(('reset', None))\n",
    "        return np.stack([master_end.recv() for master_end in self.master_ends])\n",
    "    \n",
    "    def step(self, actions):\n",
    "        self.step_async(actions)\n",
    "        return self.step_wait()\n",
    "    \n",
    "    def close(self):\n",
    "        if self.closed:\n",
    "            return\n",
    "        if self.waiting:\n",
    "            [master_end.recv() for master_end in self.master_ends]\n",
    "        for master_end in self.master_ends:\n",
    "            master_end.send(('close', None))\n",
    "        for worker in self.workers:\n",
    "            worker.join()\n",
    "            self.closed = True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "code_folding": []
   },
   "outputs": [],
   "source": [
    "class Actor_Critic(nn.Module):\n",
    "    def __init__(self, in_dim, out_dim):\n",
    "        super(Actor_Critic, self).__init__()\n",
    "        \n",
    "        self.line1 = nn.Linear(in_dim, 128)\n",
    "        self.hidden = nn.Linear(128, 128)\n",
    "        self.value_line2 = nn.Linear(128, 1)\n",
    "        self.probs_line2 = nn.Linear(128, out_dim)\n",
    "    \n",
    "    def forward(self,x):\n",
    "        x = F.relu(self.line1(x))\n",
    "        x = F.relu(self.hidden(x))\n",
    "        \n",
    "        value = self.value_line2(x)\n",
    "        probs = self.probs_line2(x)\n",
    "        probs = F.softmax(probs, dim=1)\n",
    "        \n",
    "        return Categorical(probs), value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "code_folding": [],
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "## hyperparameters ##\n",
    "\n",
    "num_envs = 16\n",
    "env_name = 'CartPole-v1'\n",
    "test_reward_target = 370\n",
    "max_epoch = 20000\n",
    "# max_timesteps 设置较小，效果越好\n",
    "max_timesteps = 5\n",
    "\n",
    "## hyperparameters ##\n",
    "\n",
    "envs = ParallelEnv(num_envs, env_name)\n",
    "state_space = envs.observation_space\n",
    "action_space = envs.action_space\n",
    "\n",
    "env = gym.make(env_name)\n",
    "\n",
    "model = Actor_Critic(state_space, action_space).to(device)\n",
    "optimizer = optim.Adam(model.parameters())\n",
    "\n",
    "gamma = 0.9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "code_folding": [
     1,
     35
    ]
   },
   "outputs": [],
   "source": [
    "#test\n",
    "def plot(frame_idx, rewards, losses):\n",
    "    clear_output(True)\n",
    "    factor = 10\n",
    "    losses_smooth_x = np.arange(len(losses))\n",
    "    losses_smooth = [np.mean(losses[i:i+factor]) if i > factor else np.mean(losses[0:i+1])\n",
    "                     for i in range(len(losses))]\n",
    "    rewards_smooth_x = np.arange(len(rewards))\n",
    "    rewards_smooth = [np.mean(rewards[i:i+factor]) if i > factor else np.mean(rewards[0:i+1])\n",
    "                      for i in range(len(rewards))]\n",
    "    \n",
    "    for i in range(len(losses)//3000):\n",
    "        losses_smooth = losses_smooth[::2] # 提取偶数索引的值 some_list[start:stop:step]\n",
    "        losses_smooth_x = losses_smooth_x[::2]\n",
    "    for i in range(len(rewards)//200):\n",
    "        rewards_smooth = rewards_smooth[::2]\n",
    "        rewards_smooth_x = rewards_smooth_x[::2]\n",
    "        \n",
    "    plt.figure(figsize=(18,10))   \n",
    "    plt.subplot(211)\n",
    "    plt.title('Epoch %s. Average reward: %s' % (frame_idx, round(mean(rewards), 3)))\n",
    "    plt.plot(rewards, label=\"Rewards\",color='lightsteelblue',linewidth='1')\n",
    "    plt.plot(rewards_smooth_x, rewards_smooth, \n",
    "             label=\"Smoothed_Rewards\",color='darkorange',linewidth='3')\n",
    "    plt.legend(loc='best')\n",
    "    \n",
    "    plt.subplot(212)\n",
    "    plt.title('loss')\n",
    "    plt.plot(losses,label=\"Losses\",color='lightsteelblue',linewidth='1')\n",
    "    plt.plot(losses_smooth_x, losses_smooth, \n",
    "             label=\"Smoothed_Losses\",color='darkorange',linewidth='3')\n",
    "    plt.legend(loc='best')\n",
    "    \n",
    "    plt.show()\n",
    "\n",
    "def test_env():\n",
    "    state = env.reset()\n",
    "    done = False\n",
    "    total_reward = 0\n",
    "    while not done:\n",
    "        state = torch.FloatTensor(state).unsqueeze(0).to(device)\n",
    "        log_prob, _ = model(state)\n",
    "        next_state, reward, done, _ = env.step(log_prob.sample().item())\n",
    "        state = next_state\n",
    "        total_reward += reward\n",
    "    return total_reward"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "code_folding": [],
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1296x720 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import pdb\n",
    "state = envs.reset()\n",
    "test_rewards = []\n",
    "losses = []\n",
    "for epoch in range(max_epoch):\n",
    "    log_probs, values, rewards, next_states, masks, gt_returns, entropy = [], [], [], [], [], [], 0\n",
    "    for _ in range(max_timesteps):\n",
    "        state = torch.FloatTensor(state).to(device)\n",
    "        prob, value = model(state)\n",
    "        \n",
    "        \n",
    "        action = prob.sample()\n",
    "        next_state, reward, done, _ = envs.step(action.cpu().numpy())\n",
    "        state = next_state\n",
    "        \n",
    "        next_states.append(torch.FloatTensor(next_state).to(device))\n",
    "        log_probs.append(prob.log_prob(action))\n",
    "        values.append(value)\n",
    "        rewards.append(torch.FloatTensor(reward).unsqueeze(1).to(device))\n",
    "        masks.append(torch.FloatTensor(1-done).unsqueeze(1).to(device))\n",
    "        entropy += prob.entropy().mean()\n",
    "        \n",
    "        if epoch % 200 == 0:\n",
    "            test_rewards.append(np.mean([test_env() for _ in range(10)]))\n",
    "            plot(epoch // 200, test_rewards, losses)\n",
    "            \n",
    "    # train\n",
    "    \n",
    "    _ , next_value = model(torch.FloatTensor(next_state).to(device))\n",
    "    G_t = next_value\n",
    "    gt_returns = []\n",
    "    \n",
    "    for i in reversed(range(len(rewards))):\n",
    "        G_t = rewards[i] + gamma * G_t * masks[i]\n",
    "        gt_returns.insert(0, G_t)\n",
    "    gt_returns = torch.cat(gt_returns)\n",
    "    \n",
    "    log_probs, values = torch.cat(log_probs),torch.cat(values)\n",
    "    \n",
    "    advantage = gt_returns - values\n",
    "    actor_loss = -(log_probs * advantage.detach()).mean()\n",
    "    critic_loss = advantage.pow(2).mean()\n",
    "    \n",
    "    loss = (actor_loss + 0.5 * critic_loss - 0.001 * entropy).to(device)\n",
    "    losses.append(loss.item())\n",
    "    \n",
    "    optimizer.zero_grad()\n",
    "    loss.backward()\n",
    "    optimizer.step()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAW4AAAD8CAYAAABXe05zAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAARdklEQVR4nO3df6zdd13H8efLbQwU4jZ2t9T+sFNqZBrp8Dpq5h9zoIzFWEzAbBppyJKLyUggIeqmiULiEk2UGaIu1mxSDDKmQNYsU5xlxPAHGy2U0lLmChR2bbN2sg0Icdrx9o/zuXDsTtvTe+/Z7eee5yM5Od/v+/s557w/6emr3/u539OTqkKS1I8fWOkGJElnx+CWpM4Y3JLUGYNbkjpjcEtSZwxuSerMxII7yfVJHk1yKMmtk3odSZo2mcR13EnOA/4D+CVgHvgMcFNVfXHZX0ySpsykzrivBg5V1Veq6n+Ae4CtE3otSZoq50/oedcCjw/tzwOvOdXgSy+9tDZu3DihViSpP4cPH+bJJ5/MqGOTCu5RL/b/1mSSzAFzABs2bGD37t0TakWS+jM7O3vKY5NaKpkH1g/trwOODA+oqu1VNVtVszMzMxNqQ5JWn0kF92eATUmuSPIi4EZg54ReS5KmykSWSqrqRJK3Ax8HzgPurqoDk3gtSZo2k1rjpqoeAB6Y1PNL0rTyk5OS1BmDW5I6Y3BLUmcMbknqjMEtSZ0xuCWpMwa3JHXG4JakzhjcktQZg1uSOmNwS1JnDG5J6ozBLUmdMbglqTMGtyR1xuCWpM4Y3JLUGYNbkjqzpK8uS3IY+BbwHHCiqmaTXAJ8GNgIHAZ+vaqeWlqbkqQFy3HG/YtVtbmqZtv+rcCuqtoE7Gr7kqRlMomlkq3Ajra9A3jjBF5DkqbWUoO7gH9NsifJXKtdXlVHAdr9ZUt8DUnSkCWtcQPXVNWRJJcBDyb50rgPbEE/B7Bhw4YltiFJ02NJZ9xVdaTdHwM+BlwNPJFkDUC7P3aKx26vqtmqmp2ZmVlKG5I0VRYd3El+KMnLFraBXwb2AzuBbW3YNuC+pTYpSfq+pSyVXA58LMnC8/xDVf1Lks8A9ya5Gfg68OaltylJWrDo4K6qrwCvGlH/L+C1S2lKknRqfnJSkjpjcEtSZwxuSeqMwS1JnTG4JakzBrckdcbglqTOGNyS1BmDW5I6Y3BLUmcMbknqjMEtSZ0xuCWpMwa3JHXG4JakzhjcktQZg1uSOmNwS1JnDG5J6swZgzvJ3UmOJdk/VLskyYNJHmv3F7d6krwvyaEk+5K8epLNS9I0GueM+/3A9SfVbgV2VdUmYFfbB3gDsKnd5oA7l6dNSdKCMwZ3Vf078I2TyluBHW17B/DGofoHauDTwEVJ1ixXs5Kkxa9xX15VRwHa/WWtvhZ4fGjcfKs9T5K5JLuT7D5+/Pgi25Ck6bPcv5zMiFqNGlhV26tqtqpmZ2ZmlrkNSVq9FhvcTywsgbT7Y60+D6wfGrcOOLL49iRJJ1tscO8EtrXtbcB9Q/W3tKtLtgDPLCypSJKWx/lnGpDkQ8C1wKVJ5oE/Av4EuDfJzcDXgTe34Q8ANwCHgO8Ab51Az5I01c4Y3FV10ykOvXbE2AJuWWpTkqRT85OTktQZg1uSOmNwS1JnDG5J6ozBLUmdMbglqTMGtyR1xuCWpM4Y3JLUGYNbkjpjcEtSZwxuSeqMwS1JnTG4JakzBrckdcbglqTOGNyS1BmDW5I6c8bgTnJ3kmNJ9g/V3p3kP5Psbbcbho7dluRQkkeTvH5SjUvStBrnjPv9wPUj6ndU1eZ2ewAgyZXAjcBPtcf8dZLzlqtZSdIYwV1V/w58Y8zn2wrcU1XPVtVXGXzb+9VL6E+SdJKlrHG/Pcm+tpRycautBR4fGjPfas+TZC7J7iS7jx8/voQ2JGm6LDa47wR+HNgMHAX+vNUzYmyNeoKq2l5Vs1U1OzMzs8g2JGn6LCq4q+qJqnquqr4L/C3fXw6ZB9YPDV0HHFlai5KkYYsK7iRrhnZ/DVi44mQncGOSC5NcAWwCHllai5KkYeefaUCSDwHXApcmmQf+CLg2yWYGyyCHgbcBVNWBJPcCXwROALdU1XOTaV2SptMZg7uqbhpRvus0428Hbl9KU5KkU/OTk5LUGYNbkjpjcEtSZwxuSeqMwS1JnTG4JakzZ7wcUKvTnu1vG1n/2bm/eYE7kXS2POOWpM4Y3JLUGYNbkjpjcEtSZwxuSeqMwS1JnTG4JakzBrckdcbglqTOGNyS1BmDW5I6c8bgTrI+yUNJDiY5kOQdrX5JkgeTPNbuL271JHlfkkNJ9iV59aQnIUnTZJwz7hPAu6rqlcAW4JYkVwK3AruqahOwq+0DvIHBt7tvAuaAO5e9a0maYmcM7qo6WlWfbdvfAg4Ca4GtwI42bAfwxra9FfhADXwauCjJmmXvXJKm1FmtcSfZCFwFPAxcXlVHYRDuwGVt2Frg8aGHzbfayc81l2R3kt3Hjx8/+84laUqNHdxJXgp8BHhnVX3zdENH1Op5hartVTVbVbMzMzPjtiFJU2+s4E5yAYPQ/mBVfbSVn1hYAmn3x1p9Hlg/9PB1wJHlaVfLxS9MkPo1zlUlAe4CDlbVe4cO7QS2te1twH1D9be0q0u2AM8sLKlIkpZunK8uuwb4LeALSfa22u8DfwLcm+Rm4OvAm9uxB4AbgEPAd4C3LmvHkjTlzhjcVfUpRq9bA7x2xPgCblliX5KkU/CTk5LUGYNbkjpjcEtSZwxuSeqMwS1JnTG4JakzBrckdcbglqTOGNyS1BmDW5I6Y3BLUmcMbknqjMEtSZ0xuCWpMwa3JHXG4JakzhjcktQZg1uSOjPOlwWvT/JQkoNJDiR5R6u/O8l/JtnbbjcMPea2JIeSPJrk9ZOcgCRNm3G+LPgE8K6q+mySlwF7kjzYjt1RVX82PDjJlcCNwE8BPwL8W5KfqKrnlrNxSZpWZzzjrqqjVfXZtv0t4CCw9jQP2QrcU1XPVtVXGXzb+9XL0awk6SzXuJNsBK4CHm6ltyfZl+TuJBe32lrg8aGHzXP6oJcknYWxgzvJS4GPAO+sqm8CdwI/DmwGjgJ/vjB0xMNrxPPNJdmdZPfx48fPunFJmlZjBXeSCxiE9ger6qMAVfVEVT1XVd8F/pbvL4fMA+uHHr4OOHLyc1bV9qqararZmZmZpcxBkqbKOFeVBLgLOFhV7x2qrxka9mvA/ra9E7gxyYVJrgA2AY8sX8uSNN3GuarkGuC3gC8k2dtqvw/clGQzg2WQw8DbAKrqQJJ7gS8yuCLlFq8okaTlc8bgrqpPMXrd+oHTPOZ24PYl9CVJOgU/OSlJnTG4JakzBrckdcbglqTOGNyS1BmDW5I6Y3BLUmcMbknqjMEtSZ0xuCWpMwa3JHXG4JakzhjcktQZg3uVSTL2bRKPlzR5BrckdWacL1LQKnb/0bnvbf/Kmu0r2ImkcXnGPcWGQ3vUvqRzk8EtSZ0Z58uCX5zkkSSfT3IgyXta/YokDyd5LMmHk7yo1S9s+4fa8Y2TnYIkTZdxzrifBa6rqlcBm4Hrk2wB/hS4o6o2AU8BN7fxNwNPVdUrgDvaOJ2DTl7Tdo1b6sM4XxZcwLfb7gXtVsB1wG+0+g7g3cCdwNa2DfBPwF8mSXsenUNm37Yd+H5Yv3vFOpF0Nsa6qiTJecAe4BXAXwFfBp6uqhNtyDywtm2vBR4HqKoTSZ4BXg48earn37Nnj9cFd8g/M2lljBXcVfUcsDnJRcDHgFeOGtbuR/1tft7ZdpI5YA5gw4YNfO1rXxurYZ3eCxmm/hAlTc7s7Owpj53VVSVV9TTwSWALcFGSheBfBxxp2/PAeoB2/IeBb4x4ru1VNVtVszMzM2fThiRNtXGuKplpZ9okeQnwOuAg8BDwpjZsG3Bf297Z9mnHP+H6tiQtn3GWStYAO9o69w8A91bV/Um+CNyT5I+BzwF3tfF3AX+f5BCDM+0bJ9C3JE2tca4q2QdcNaL+FeDqEfX/Bt68LN1Jkp7HT05KUmcMbknqjMEtSZ3xv3VdZbyAR1r9POOWpM4Y3JLUGYNbkjpjcEtSZwxuSeqMwS1JnTG4JakzBrckdcbglqTOGNyS1BmDW5I6Y3BLUmcMbknqjMEtSZ0Z58uCX5zkkSSfT3IgyXta/f1Jvppkb7ttbvUkeV+SQ0n2JXn1pCchSdNknP+P+1nguqr6dpILgE8l+ed27Heq6p9OGv8GYFO7vQa4s91LkpbBGc+4a+DbbfeCdjvd/9a/FfhAe9yngYuSrFl6q5IkGHONO8l5SfYCx4AHq+rhduj2thxyR5ILW20t8PjQw+dbTZK0DMYK7qp6rqo2A+uAq5P8NHAb8JPAzwGXAL/XhmfUU5xcSDKXZHeS3cePH19U85I0jc7qqpKqehr4JHB9VR1tyyHPAn8HXN2GzQPrhx62Djgy4rm2V9VsVc3OzMwsqnlJmkbjXFUyk+Sitv0S4HXAlxbWrZMEeCOwvz1kJ/CWdnXJFuCZqjo6ke4laQqNc1XJGmBHkvMYBP29VXV/kk8kmWGwNLIX+O02/gHgBuAQ8B3grcvftiRNrzMGd1XtA64aUb/uFOMLuGXprUmSRvGTk5LUGYNbkjpjcEtSZwxuSeqMwS1JnTG4JakzBrckdcbglqTOGNyS1BmDW5I6Y3BLUmcMbknqjMEtSZ0xuCWpMwa3JHXG4JakzhjcktQZg1uSOmNwS1JnDG5J6ozBLUmdMbglqTOpqpXugSTfAh5d6T4m5FLgyZVuYgJW67xg9c7NefXlR6tqZtSB81/oTk7h0aqaXekmJiHJ7tU4t9U6L1i9c3Neq4dLJZLUGYNbkjpzrgT39pVuYIJW69xW67xg9c7Nea0S58QvJyVJ4ztXzrglSWNa8eBOcn2SR5McSnLrSvdztpLcneRYkv1DtUuSPJjksXZ/casnyfvaXPclefXKdX56SdYneSjJwSQHkryj1bueW5IXJ3kkyefbvN7T6lckebjN68NJXtTqF7b9Q+34xpXs/0ySnJfkc0nub/urZV6Hk3whyd4ku1ut6/fiUqxocCc5D/gr4A3AlcBNSa5cyZ4W4f3A9SfVbgV2VdUmYFfbh8E8N7XbHHDnC9TjYpwA3lVVrwS2ALe0P5ve5/YscF1VvQrYDFyfZAvwp8AdbV5PATe38TcDT1XVK4A72rhz2TuAg0P7q2VeAL9YVZuHLv3r/b24eFW1Yjfg54GPD+3fBty2kj0tch4bgf1D+48Ca9r2GgbXqQP8DXDTqHHn+g24D/il1TQ34AeBzwKvYfABjvNb/XvvS+DjwM+37fPbuKx076eYzzoGAXYdcD+Q1TCv1uNh4NKTaqvmvXi2t5VeKlkLPD60P99qvbu8qo4CtPvLWr3L+bYfo68CHmYVzK0tJ+wFjgEPAl8Gnq6qE23IcO/fm1c7/gzw8he247H9BfC7wHfb/stZHfMCKOBfk+xJMtdq3b8XF2ulPzmZEbXVfJlLd/NN8lLgI8A7q+qbyagpDIaOqJ2Tc6uq54DNSS4CPga8ctSwdt/FvJL8CnCsqvYkuXahPGJoV/Mack1VHUlyGfBgki+dZmxvcztrK33GPQ+sH9pfBxxZoV6W0xNJ1gC0+2Ot3tV8k1zAILQ/WFUfbeVVMTeAqnoa+CSDNfyLkiycyAz3/r15teM/DHzjhe10LNcAv5rkMHAPg+WSv6D/eQFQVUfa/TEG/9hezSp6L56tlQ7uzwCb2m++XwTcCOxc4Z6Ww05gW9vexmB9eKH+lvZb7y3AMws/6p1rMji1vgs4WFXvHTrU9dySzLQzbZK8BHgdg1/mPQS8qQ07eV4L830T8IlqC6fnkqq6rarWVdVGBn+PPlFVv0nn8wJI8kNJXrawDfwysJ/O34tLstKL7MANwH8wWGf8g5XuZxH9fwg4Cvwvg3/pb2awVrgLeKzdX9LGhsFVNF8GvgDMrnT/p5nXLzD48XIfsLfdbuh9bsDPAJ9r89oP/GGr/xjwCHAI+EfgwlZ/cds/1I7/2ErPYYw5Xgvcv1rm1ebw+XY7sJATvb8Xl3Lzk5OS1JmVXiqRJJ0lg1uSOmNwS1JnDG5J6ozBLUmdMbglqTMGtyR1xuCWpM78Hz+H7YVCqVMrAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from IPython import display\n",
    "\n",
    "env = gym.make(env_name)\n",
    "state_1 = env.reset()\n",
    "img = plt.imshow(env.render(mode='rgb_array')) # only call this once\n",
    "for _ in range(1000):\n",
    "    img.set_data(env.render(mode='rgb_array')) # just update the data\n",
    "    display.display(plt.gcf())\n",
    "    display.clear_output(wait=True)\n",
    "    model = model.cpu()\n",
    "    \n",
    "    prob, value = model(torch.FloatTensor(state_1).unsqueeze(0))\n",
    "    action = prob.sample().item()\n",
    "    next_state, _, done, _ = env.step(action)\n",
    "    if done: \n",
    "        state = env.reset()\n",
    "    state_1 = next_state"
   ]
  }
 ],
 "metadata": {
  "hide_input": false,
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.8"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "oldHeight": 918.8,
   "position": {
    "height": "940.4px",
    "left": "408px",
    "right": "20px",
    "top": "58px",
    "width": "557.4px"
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "varInspector_section_display": "block",
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
